home *** CD-ROM | disk | FTP | other *** search
/ Amiga Collections: Taifun / Taifun 159 (1991-03-10)(Manewaldt, A.)(DE)(PD).zip / Taifun 159 (1991-03-10)(Manewaldt, A.)(DE)(PD).adf / Route / RoadScan.c < prev    next >
C/C++ Source or Header  |  1991-02-20  |  20KB  |  604 lines
  1. /* after years of fiddling..
  2.   'v1.1  August 90
  3. 'Jim Butterfield  */
  4.  
  5.    /* compile with lc -Lcd -v <filename> */
  6. #include <proto/exec.h>
  7. #include <proto/dos.h>
  8. #include <stdio.h>
  9. #define BUFFERLINE 50
  10. #define INFOSIZE sizeof(struct FileInfoBlock)
  11. #define TRAILLEN 60
  12.  
  13. /* File Support structures */
  14. struct CityData {
  15.                 char *CityName;              /* full name  w/state */
  16.                 char *StateName;             /* state/province only */
  17.                 struct CityData *CityLink;   /* init letter chain */
  18.                 struct CityData *StateLink;  /* init letter chain */
  19.                 struct RouteData *RoadList;  /* roads to/from city */
  20.                 struct CityData *WorkList;   /* temp job queue */
  21.                 struct CityData *NextCity[2];  /* result links */
  22.       /* Mindist[0] doubles as CityDupe flag during file input */
  23.                 unsigned short MinDist[2];   /* closest so far */
  24.                 unsigned char StateDupe;     /* one name per state */
  25.                 unsigned char Colum;         /* goes with RoadList */
  26.                 };
  27. struct RouteData {
  28.                  struct CityData *CityNum[2];  /* cities each end */
  29.                  unsigned short Dist[2];       /* distance, time */
  30.                  char *Hiway;                  /* name of Highway */
  31.                  struct RouteData *RLink[2];   /* link for each city */
  32.                  unsigned char Colm[2];        /* goes with RLink */
  33.                  };
  34. struct RouteData *Route0, *Route9;
  35. struct CityData *City0, *City9;
  36. struct CityData *CharLink[0x20];
  37. struct CityData *ChStLink[0x20];
  38. struct CityData *CityLink[0x100];     /* The only 1.1 change! */
  39. struct CityData *CountLink[5];
  40. static char InBuff[BUFFERLINE];
  41. static struct CityData *Trail[TRAILLEN][2];
  42. unsigned short TrailPoint[2];
  43. void TimeShow(unsigned short,char *);
  44. int CityMatch(struct CityData *,char *);
  45. unsigned short ParseCities(char *,long);
  46. unsigned short ParseRoutes(char *,long);
  47. struct CityData * AskCity();
  48. unsigned short Navigate(struct CityData *,struct CityData *);
  49. void main()
  50.   {
  51.   long fh, lok;
  52.   unsigned short NextCol, NewCol;
  53.   unsigned short AllocCount, errnum;
  54.   struct FileInfoBlock *fibb;
  55.   long CitySize, RouteSize;
  56.   char *CityBlox, *RouteBlox, *DataScan, *Active;
  57.   char *CityScan, *CityPoint, *RoutePoint;
  58.   struct CityData *From, *Dest;
  59.   struct RouteData *NextRoute, *NewRoute, *ScanRoute;
  60.   unsigned short Cities, Roads;
  61.   unsigned short CityPSize, RoutePSize;
  62.   unsigned char Ct0;             /* general character work value */
  63.   unsigned short Count, Links;
  64.   static char ActCity[]="Cities";
  65.   static char ActRoad[]="Roads";
  66.   for (Ct0=0; Ct0 < 0x20; Ct0++) CharLink[Ct0]= 0;
  67.   for (Ct0=0; Ct0 < 0x20; Ct0++) ChStLink[Ct0]= 0;
  68.   for (Ct0=0; Ct0 < 5; Ct0++) CountLink[Ct0]= 0;
  69.   AllocCount=0;
  70.   errnum=2;                   /* no memory */
  71.   if ( (long) (fibb = (struct FileInfoBlock *) AllocMem(INFOSIZE,0L))
  72.                                                                 != 0L)
  73.     {
  74.     AllocCount=1;
  75.     errnum=3;                   /* file problems */
  76.     fprintf(stderr,"RoadScan V1.1  ..   Jim Butterfield\n");
  77.     fprintf(stderr,"   Release version:  1990 08 13\n");
  78.     Cities=0;
  79.     Active=ActCity;
  80.     if ( (lok = Lock("Cities",ACCESS_READ)) != 0L)
  81.       {
  82.       if ( (fh=Examine(lok,fibb)) !=0L)
  83.         {
  84.         CitySize=fibb->fib_Size;
  85.         if ( (long) (CityBlox = AllocMem(CitySize,0L)) != 0L)
  86.       {
  87.           AllocCount=2;
  88.           if ( (fh = Open("Cities",MODE_OLDFILE)) != 0L)
  89.             {
  90.             errnum=0;
  91.             Read(fh,CityBlox,CitySize);
  92.             Close(fh);
  93.         }                      /* City file opened   */
  94.           }                        /* data alloc OK */
  95.     }                          /* examine OK    */
  96.         UnLock(lok);
  97.       }                            /* lock OK          */
  98.     }                              /* examine alloc OK */
  99.   if (errnum == 0)
  100.     {
  101.     for (DataScan=CityBlox;DataScan < CityBlox+CitySize;DataScan++)
  102.       if (*DataScan == 0x0A) Cities++;
  103.     CityPSize=Cities*sizeof(struct CityData);
  104.     if ( (long) (CityPoint = AllocMem(CityPSize,0L)) != 0L)
  105.       AllocCount=3;
  106.     else
  107.       errnum=2;
  108.     }
  109.   if (errnum ==0 )
  110.     {
  111.     errnum=3;                   /* file problems */
  112.     Active=ActRoad;
  113.     Roads=0;
  114.     if ( (lok = Lock("Roads",ACCESS_READ)) != 0L)
  115.       {
  116.       if ( (fh=Examine(lok,fibb)) !=0L)
  117.         {
  118.         RouteSize=fibb->fib_Size;
  119.         if ( (long) (RouteBlox = AllocMem(RouteSize,0L)) != 0L)
  120.           {
  121.           AllocCount=4;
  122.           if ( (fh = Open("Roads",MODE_OLDFILE)) != 0L)
  123.             {
  124.             errnum=0;
  125.             Read(fh,RouteBlox,RouteSize);
  126.             Close(fh);
  127.             }                      /* file opened   */
  128.           }                        /* data alloc OK */
  129.         }                          /* examine OK    */
  130.       UnLock(lok);
  131.       }                            /* lock OK          */
  132.     }
  133.   if (errnum == 0)
  134.     {
  135.     for (DataScan=RouteBlox;DataScan < RouteBlox+RouteSize;DataScan++)
  136.       if (*DataScan == 0x0A) Roads++;
  137.     RoutePSize=Roads*sizeof(struct RouteData);
  138.     if ( (long) (RoutePoint = AllocMem(RoutePSize,0L)) != 0L)
  139.       AllocCount=5;
  140.     else
  141.       errnum=2;
  142.     }
  143.   if (errnum == 0)
  144.     {
  145.     Active=ActCity;
  146.     fprintf(stderr,">> %d Cities\n",Cities);
  147.     City0 = (struct CityData *) CityPoint;
  148.     errnum=ParseCities(CityBlox,CitySize);
  149.     }
  150.   if (errnum == 0)
  151.     {
  152.     Active=ActRoad;
  153.     fprintf(stderr,">> %d Roads\n",Roads);
  154.     Route0 = (struct RouteData *) RoutePoint;
  155.     errnum=ParseRoutes(RouteBlox,RouteSize);
  156.     }
  157.   switch (errnum)
  158.     {
  159.     case 0:                /* no errors, do main job */
  160.       printf("Scanning Cities...\n\n");
  161.       From=City0;
  162.       while (From<City9)
  163.        {
  164.        CityScan=From->CityName;
  165.        while (*(++CityScan) != ',');
  166.        *CityScan=0;
  167.        Count=0;
  168.        NextRoute=From->RoadList;
  169.        NextCol=From->Colum;
  170.        while (NextRoute != 0)
  171.      {
  172.          Dest=NextRoute->CityNum[1-NextCol];
  173.          for (Links=0; Links<Count; Links++)
  174.            if (CityLink[Links]==Dest && From>Dest )
  175.              printf("DUPE: %s,%s TO %s\n",
  176.            Dest->CityName,Dest->StateName,From->CityName);
  177.          CityLink[Count]=Dest;
  178.      Count++;
  179.      NewRoute=NextRoute->RLink[NextCol];
  180.      NewCol=NextRoute->Colm[NextCol];
  181.      NextRoute=NewRoute;
  182.      NextCol=NewCol;
  183.      }
  184.        if ( Count<5 )
  185.      {
  186.      From->WorkList=CountLink[Count];
  187.      CountLink[Count]=From;
  188.      }
  189.        From++;
  190.        }
  191.       From = CountLink[0];
  192.       if ( From !=0 )
  193.        {
  194.        printf("Following Cities have NO Roads !?!...\n");
  195.        printf(">>> connect or eliminate them!\n");
  196.        while (From != 0)
  197.        {
  198.        printf(" %s\n",From->CityName);
  199.        From = From->WorkList;
  200.        }
  201.        }
  202.       for (Count=1; Count<=3; Count++)
  203.         {
  204.         From = CountLink[Count];
  205.         if ( From!=0 )
  206.          {
  207.          printf("Following Cities have %d Roads...\n",Count);
  208.          printf(">>> you could save space if they were not needed!\n");
  209.          while (From != 0)
  210.            {
  211.            printf(" %s,%s ",From->CityName,From->StateName);
  212.            Ct0='[';
  213.            NextRoute=From->RoadList;
  214.            NextCol=From->Colum;
  215.            while (NextRoute != 0)
  216.              {
  217.              Dest=NextRoute->CityNum[1-NextCol];
  218.          printf("%c%s",Ct0,Dest->CityName);
  219.              NewRoute=NextRoute->RLink[NextCol];
  220.              NewCol=NextRoute->Colm[NextCol];
  221.              NextRoute=NewRoute;
  222.              NextCol=NewCol;
  223.          Ct0='-';
  224.          } /* wend, connecting-city list loop */
  225.  
  226.        printf("]\n");
  227.        From = From->WorkList;
  228.        }  /* wend, next city for this count-list */
  229.          }  /* endif count-list not empty */
  230.         }   /* next count-list  */
  231.       Ct0=0;
  232.       for (ScanRoute=Route0; ScanRoute<Route9; ScanRoute++)
  233.         {
  234.         TrailPoint[0]=0;
  235.         TrailPoint[1]=0;
  236.         From=ScanRoute->CityNum[0];
  237.         Dest=ScanRoute->CityNum[1];
  238.     if ( Navigate(From,Dest)>1 )
  239.           {
  240.               if (Ct0==0)
  241.                  printf("... Following DIRECT routes are not shortest!\n");
  242.               Ct0=1;
  243.           printf("%s,%s->%s \n",
  244.              From->CityName,From->StateName,Dest->CityName);
  245.               }
  246.         }           /* next Road to analyze */
  247.       break;
  248.     case 1:         /* trouble in file data */
  249.       fprintf(stderr,"----> Correct data in file %s and try again.\n",Active);
  250.       break;
  251.     case 2:         /* AllocMem refused */
  252.         fprintf(stderr,"----> Not enough memory to run RoadRoute.\n");
  253.     break;
  254.     case 3:         /* real trouble with file */
  255.         fprintf(stderr,"----> Can't proceed due to unreadable file %s.\n",Active);
  256.         break;
  257.     default:
  258.       fprintf(stderr,"System error: %d\n",errnum);
  259.     }  /* error switch area */
  260.   switch (AllocCount)
  261.     {
  262.     case 5:  FreeMem(RoutePoint,RoutePSize);
  263.     case 4:  FreeMem( (char *) RouteBlox,RouteSize);
  264.     case 3:  FreeMem(CityPoint,CityPSize);
  265.     case 2:  FreeMem( (char *) CityBlox,CitySize);
  266.     case 1:  FreeMem( (char *) fibb,INFOSIZE);
  267.     }  /* memory cleanup */
  268.   if (errnum != 0)
  269.     {
  270.     fprintf(stderr,"Press any key to quit\n");
  271.     gets(InBuff);
  272.     }    
  273.   }
  274.  
  275.  
  276. void TimeShow(Time, Buffer)
  277.   unsigned short Time;
  278.   char *Buffer;
  279.   {
  280.   unsigned short MinFlag, radix, digit, SuppressLimit, FillChar, Hours[2];
  281.   Hours[0]=Time/60;
  282.   Hours[1]=Time%60;
  283.   SuppressLimit=1;
  284.   FillChar=':';
  285.   radix=10000;
  286.   while (radix>Hours[0] && radix>SuppressLimit)
  287.     {
  288.     radix/=10;
  289.     *Buffer++ =' ';
  290.     }
  291.   for (MinFlag=0;MinFlag<2;MinFlag++)
  292.     {
  293.     while (radix>0)
  294.       {
  295.       digit=Hours[MinFlag]/radix;
  296.       Hours[MinFlag]%=radix;
  297.       *Buffer++ =digit+'0';
  298.       radix/=10;
  299.       }  /* more digits */
  300.     *Buffer++ =FillChar;
  301.     FillChar=0;
  302.     SuppressLimit=10;
  303.     radix=10;
  304.     }  /* next MinFlag */
  305.   }
  306.  
  307. int CityMatch(TabPoint,CityText)
  308.   struct CityData *TabPoint;
  309.   char *CityText;
  310.   {
  311.   /* Name must match exactly; state is optional */
  312.   int Match, StateMatch;
  313.   char TablChar, TextChar;
  314.   char *TableName;
  315.   TableName=TabPoint->CityName;
  316.   TablChar=*TableName++; if (TablChar > 'Z') TablChar-=0x20;
  317.   TextChar=*CityText++; if (TextChar > 'Z') TextChar-=0x20;
  318.   Match=1;
  319.   StateMatch=0;
  320.   while (Match == 1 && TextChar != ',')
  321.     {
  322.     if (TablChar != TextChar)
  323.       {
  324.       if (TablChar ==',' && TextChar =='/') StateMatch=1;
  325.       else Match=0;
  326.       }
  327.     TablChar=*TableName++; if (TablChar > 'Z') TablChar-=0x20;
  328.     TextChar=*CityText++; if (TextChar > 'Z') TextChar-=0x20;
  329.     }
  330.   if (Match==1)
  331.     {
  332.     if (TablChar != 0 && TablChar !=',') Match=0;
  333.     if (TabPoint->MinDist[0]==1 && StateMatch ==0) Match=0;
  334.     }
  335.   return (Match);
  336.   }
  337.  
  338. unsigned short ParseCities(CitiesBlock,CBlockSize)
  339.   char *CitiesBlock;
  340.   long CBlockSize;
  341.   {
  342.   struct CityData *CityStruct, *CityScan;
  343.   char *LineBegin, *EndLine, *NewName, *OldName;
  344.   unsigned short CityError;
  345.   unsigned char CityIndex,NewChar,OldChar;
  346.   unsigned char FoundFlag, StateFlag;
  347.   CityError=0;
  348.   CityStruct = City0;
  349.   LineBegin = CitiesBlock;
  350.   FoundFlag=0;
  351.   for (EndLine=CitiesBlock;EndLine < CitiesBlock+CBlockSize;EndLine++)
  352.   if (*EndLine == ',' || *EndLine == 0x0A)
  353.     {
  354.     if (*EndLine == ',')
  355.       {
  356.       FoundFlag=1;
  357.       CityStruct->CityName=LineBegin;
  358.       /* MinDist[0] used as temporary dupe CityName flag */
  359.       CityStruct->MinDist[0]=0;          /* No City Duplicate Name */
  360.       CityIndex = *LineBegin & 0x1F;        /* strip first char */
  361.       CityScan = CharLink[CityIndex];
  362.       while (CityScan != 0)
  363.         {
  364.         NewName=LineBegin;
  365.         OldName=CityScan->CityName;
  366.         NewChar=*NewName++; if (NewChar > 0x60) NewChar -= 0x20;
  367.         OldChar=*OldName++; if (OldChar > 0x60) OldChar -= 0x20;
  368.         while (NewChar == OldChar && NewChar != ',')
  369.           {
  370.           NewChar=*NewName++; if (NewChar > 0x60) NewChar -= 0x20;
  371.           OldChar=*OldName++; if (OldChar > 0x60) OldChar -= 0x20;
  372.           }
  373.         if (NewChar == OldChar)     /* Dupe City Name */
  374.           {
  375.           CityStruct->MinDist[0]=1;
  376.           CityScan->MinDist[0]=1;
  377.           }
  378.         CityScan = CityScan->CityLink;
  379.         }   /* chain search for input city name */
  380.        CityStruct->CityLink = CharLink[CityIndex];
  381.       CityStruct->RoadList = 0;
  382.       CharLink[CityIndex]=CityStruct;
  383.       LineBegin=EndLine+1;
  384.       }    /* end of comma..City parsing */
  385.     else     /* NewLine */
  386.       {
  387.       *EndLine=0;
  388.       if (FoundFlag ==0)
  389.         {
  390.         fprintf(stderr,"*FILE Cities: NO COMMA:\n%s\n",LineBegin);
  391.         CityError=1;
  392.         }
  393.       FoundFlag=0;
  394.       CityStruct->StateName=LineBegin;
  395.       CityStruct->StateDupe=1;
  396.       CityIndex = *LineBegin & 0x1F;        /* strip first char */
  397.       CityScan = ChStLink[CityIndex];
  398.       StateFlag = 0;
  399.       while (CityScan != 0 && StateFlag == 0)
  400.         {
  401.         NewName=LineBegin;
  402.         OldName=CityScan->StateName;
  403.         NewChar=*NewName++; if (NewChar > 0x60) NewChar -= 0x20;
  404.         OldChar=*OldName++; if (OldChar > 0x60) OldChar -= 0x20;
  405.         while (NewChar == OldChar && NewChar !=0 && OldChar !=0)
  406.           {
  407.           NewChar=*NewName++; if (NewChar > 0x60) NewChar -= 0x20;
  408.           OldChar=*OldName++; if (OldChar > 0x60) OldChar -= 0x20;
  409.           }
  410.         if (NewChar == OldChar)
  411.           {
  412.           CityScan->StateDupe=0;
  413.           StateFlag=1;
  414.           }
  415.         CityScan = CityScan->StateLink;
  416.         }   /* more states in chain */
  417.       CityStruct->StateLink = ChStLink[CityIndex];
  418.       ChStLink[CityIndex]=CityStruct;
  419.       CityStruct++;
  420.       LineBegin=EndLine+1;
  421.       }    /* end of NewLine parsing */
  422.     }
  423.   City9=CityStruct;
  424.   return(CityError);
  425.   }
  426.  
  427. unsigned short ParseRoutes(DataBlock,BlockSize)
  428.   char *DataBlock;
  429.   long BlockSize;
  430.   {
  431.   struct RouteData *RouteStruct;
  432.   struct CityData *CityScan, *FoundCity;
  433.   unsigned short ErrorFlag, CityColm, CityFlag, CityValue, Multiplier;
  434.   unsigned char CtNameKey, Digit;
  435.   char *LineStart,*LineEnd,*FieldStart,*FieldEnd,*NumPtr;
  436.   ErrorFlag=0;
  437.   RouteStruct = Route0;
  438.   LineStart = DataBlock;
  439.   for (LineEnd=DataBlock;LineEnd < DataBlock+BlockSize;LineEnd++)
  440.   if (*LineEnd == 0x0A)
  441.     {
  442.     *LineEnd=0;
  443.     FieldStart=LineStart;
  444.     for (CityColm=0 ; ErrorFlag==0 && CityColm < 2 ; CityColm++)
  445.       {
  446.       for (FieldEnd=FieldStart ;
  447.              *FieldEnd !=',' && FieldEnd < LineEnd ; FieldEnd++);
  448.       if (*FieldEnd !=',')
  449.         {
  450.         fprintf(stderr,"*FILE Roads:  MISSING FIELDS:\n%s\n",LineStart);
  451.         ErrorFlag=1;
  452.         }   /* no comma! */
  453.       /* ***** search city name chain */
  454.       CtNameKey = *FieldStart & 0x1F;        /* strip first char */
  455.       CityScan = CharLink[CtNameKey];
  456.       CityValue =0;
  457.       while (CityScan != 0 && CityValue ==0)
  458.         {
  459.         if (CityMatch(CityScan,FieldStart)==1)
  460.           {
  461.           CityValue=1;
  462.           FoundCity=CityScan;
  463.           }
  464.         CityScan = CityScan->CityLink;
  465.         }   /* chain search for input city name */      
  466.       if (CityValue ==0)
  467.         {
  468.         fprintf(stderr,"*FILE Roads:  CITY NOT FOUND:\n%s\n",LineStart);
  469.         ErrorFlag=1;
  470.         }
  471.       RouteStruct->CityNum[CityColm]=FoundCity;
  472.       RouteStruct->RLink[CityColm]=FoundCity->RoadList;
  473.       RouteStruct->Colm[CityColm]=FoundCity->Colum;
  474.       FoundCity->RoadList=RouteStruct;
  475.       FoundCity->Colum=CityColm;
  476.       FieldStart=FieldEnd+1;
  477.       }   /* two-city loop */
  478.     /* Now grab mileage, time, and Hiway */
  479.     for (CityColm=0 ; ErrorFlag==0 && CityColm < 2 ; CityColm++)
  480.       {
  481.       for (FieldEnd=FieldStart ;
  482.                 *FieldEnd !=',' && FieldEnd < LineEnd ; FieldEnd++);
  483.       if (*FieldEnd !=',')
  484.         {
  485.         fprintf(stderr,"FILE Roads:  MISSING FIELDS:\n%s????\n",LineStart);
  486.         ErrorFlag=1;
  487.         }   /* no comma! */
  488.       CityValue=0 ; CityFlag=0;
  489.       Multiplier=10;
  490.       for (NumPtr=FieldStart ; CityFlag==0 && NumPtr < FieldEnd ;
  491.                                                           NumPtr++)
  492.         {
  493.         Digit=*NumPtr;
  494.         if (Digit >='0' && Digit<='9')
  495.           {
  496.           CityValue=CityValue * Multiplier + Digit - '0';
  497.           Multiplier=10;
  498.           }
  499.         else if (Digit ==':') Multiplier = 6;
  500.         }  /* Scan for colon */
  501.       RouteStruct->Dist[CityColm]=CityValue;
  502.       FieldStart=FieldEnd+1;
  503.       }    /* Two value paramemters */
  504.     RouteStruct->Hiway=FieldStart;
  505.     RouteStruct++;
  506.     LineStart=LineEnd+1;
  507.     }    /* end of routefile scan */
  508.   Route9 = RouteStruct;
  509.   return(ErrorFlag);
  510.   }   /* if no error, table build */
  511.  
  512. #define MENUSIZE 30
  513.  
  514. unsigned short Navigate(struct CityData *Start,struct CityData *Finish)
  515.   {
  516.   unsigned short Column, Travel;
  517.   unsigned short NextCol, NewCol;
  518.   struct CityData *CityScan;
  519.   struct CityData *BLink, *SearchCity;
  520.   struct CityData *ELink, *FLink, *OtherCity;
  521.   struct RouteData *NextRoute, *NewRoute;
  522.   static unsigned short MiniVal;
  523.   static unsigned short ThisDist[2], LCount[2];
  524.         for (CityScan=City0; CityScan<City9; CityScan++)
  525.           {
  526.           CityScan->WorkList = 0;
  527.           for (Column=0; Column<2; Column++)
  528.             {
  529.             CityScan->MinDist[Column]=9999;
  530.             CityScan->NextCity[Column]=0;
  531.             }
  532.           }
  533.         ELink=Finish;
  534.         MiniVal=0;
  535.         for (Column=0; Column<2; Column++)
  536.           {
  537.           Finish->MinDist[Column]=0;
  538.           ThisDist[Column]=9999;
  539.           }
  540.         SearchCity=Finish;       
  541.         while (SearchCity != 0)
  542.           {
  543.           for (Column=0; Column<2; Column++)
  544.             {
  545.             if (SearchCity->MinDist[Column] < Start->MinDist[Column])
  546.               {
  547.     /*   if (Column==0)
  548.      *   printf("Scanning map at range: %d\n",SearchCity->MinDist[0]); */
  549.               MiniVal=SearchCity->MinDist[Column];
  550.               NextRoute=SearchCity->RoadList;
  551.               NextCol=SearchCity->Colum;
  552.               while (NextRoute != 0)
  553.                 {
  554.                 OtherCity=NextRoute->CityNum[1-NextCol];
  555.                 Travel=MiniVal+NextRoute->Dist[Column];
  556.                 if (OtherCity->MinDist[Column] > Travel)
  557.                   /* found a new shortest path */
  558.                   {
  559.                   OtherCity->MinDist[Column]=Travel;
  560.                   OtherCity->NextCity[Column]=SearchCity;
  561.                   if (OtherCity->WorkList == 0 && ELink!=OtherCity)
  562.                     {
  563.                     BLink=SearchCity;
  564.                     FLink=SearchCity->WorkList;
  565.                     while (FLink!=0 && Travel>FLink->MinDist[Column])
  566.                       {
  567.                       BLink=FLink;
  568.                       FLink=BLink->WorkList;
  569.                       }
  570.                     BLink->WorkList=OtherCity;
  571.                     OtherCity->WorkList=FLink;
  572.                     if (FLink==0) ELink=OtherCity;
  573.                     }  /* build new Worklist */
  574.                   }    /* shorter total distance */
  575.                 if (Travel < ThisDist[Column]) ThisDist[Column]=Travel; 
  576.                 NewRoute=NextRoute->RLink[NextCol];
  577.                 NewCol=NextRoute->Colm[NextCol];
  578.                 NextRoute=NewRoute;
  579.                 NextCol=NewCol;
  580.                 }   /* Try another route from SearchCity */
  581.               }     /* if Search City within target range */
  582.             }       /* Next Column (Mileage/Time) */
  583.           BLink=SearchCity->WorkList;
  584.           SearchCity->WorkList=0;
  585.           SearchCity=BLink;
  586.           }  /* if SearchCity not zero, go back */
  587.         for (Column=0; Column<2; Column++)
  588.           {
  589.           LCount[Column]=0;
  590.           SearchCity=Start;
  591.           FLink=SearchCity->NextCity[Column];
  592.           while (FLink != 0)
  593.             {
  594.             LCount[Column]+=1;
  595.             Trail[TrailPoint[Column]++][Column]=FLink;
  596.             SearchCity=FLink;
  597.             FLink=SearchCity->NextCity[Column];
  598.             }  /* wend for next FLink */
  599.           }    /* next Column */
  600.   MiniVal=LCount[0];
  601.   if (MiniVal<LCount[1]) MiniVal=LCount[1];
  602.   return(MiniVal);
  603.   }
  604.